/* 
 * Copyright 2013-2020 Modeliosoft
 * 
 * This file is part of Modelio.
 * 
 * Modelio is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * Modelio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Modelio.  If not, see <http://www.gnu.org/licenses/>.
 * 
 */
package org.modelio.metamodel.impl.expert.standard.links.impl.creation;

import java.util.HashSet;
import java.util.Set;
import com.modeliosoft.modelio.javadesigner.annotations.objid;
import org.modelio.metamodel.bpmn.activities.BpmnActivity;
import org.modelio.metamodel.bpmn.activities.BpmnAdHocSubProcess;
import org.modelio.metamodel.bpmn.activities.BpmnBusinessRuleTask;
import org.modelio.metamodel.bpmn.activities.BpmnCallActivity;
import org.modelio.metamodel.bpmn.activities.BpmnManualTask;
import org.modelio.metamodel.bpmn.activities.BpmnReceiveTask;
import org.modelio.metamodel.bpmn.activities.BpmnScriptTask;
import org.modelio.metamodel.bpmn.activities.BpmnSendTask;
import org.modelio.metamodel.bpmn.activities.BpmnServiceTask;
import org.modelio.metamodel.bpmn.activities.BpmnSubProcess;
import org.modelio.metamodel.bpmn.activities.BpmnTask;
import org.modelio.metamodel.bpmn.activities.BpmnTransaction;
import org.modelio.metamodel.bpmn.activities.BpmnUserTask;
import org.modelio.metamodel.bpmn.events.BpmnBoundaryEvent;
import org.modelio.metamodel.bpmn.events.BpmnCatchEvent;
import org.modelio.metamodel.bpmn.events.BpmnEndEvent;
import org.modelio.metamodel.bpmn.events.BpmnEvent;
import org.modelio.metamodel.bpmn.events.BpmnImplicitThrowEvent;
import org.modelio.metamodel.bpmn.events.BpmnIntermediateCatchEvent;
import org.modelio.metamodel.bpmn.events.BpmnIntermediateThrowEvent;
import org.modelio.metamodel.bpmn.events.BpmnStartEvent;
import org.modelio.metamodel.bpmn.events.BpmnThrowEvent;
import org.modelio.metamodel.bpmn.flows.BpmnMessageFlow;
import org.modelio.metamodel.bpmn.flows.BpmnSequenceFlow;
import org.modelio.metamodel.bpmn.gateways.BpmnComplexGateway;
import org.modelio.metamodel.bpmn.gateways.BpmnEventBasedGateway;
import org.modelio.metamodel.bpmn.gateways.BpmnExclusiveGateway;
import org.modelio.metamodel.bpmn.gateways.BpmnGateway;
import org.modelio.metamodel.bpmn.gateways.BpmnInclusiveGateway;
import org.modelio.metamodel.bpmn.gateways.BpmnParallelGateway;
import org.modelio.metamodel.bpmn.objects.BpmnDataAssociation;
import org.modelio.metamodel.bpmn.objects.BpmnDataInput;
import org.modelio.metamodel.bpmn.objects.BpmnDataObject;
import org.modelio.metamodel.bpmn.objects.BpmnDataOutput;
import org.modelio.metamodel.bpmn.objects.BpmnDataStore;
import org.modelio.metamodel.bpmn.processCollaboration.BpmnParticipant;
import org.modelio.metamodel.impl.expert.standard.links.ILinkExpert;
import org.modelio.metamodel.mda.ModuleComponent;
import org.modelio.metamodel.uml.behavior.activityModel.AcceptCallEventAction;
import org.modelio.metamodel.uml.behavior.activityModel.AcceptChangeEventAction;
import org.modelio.metamodel.uml.behavior.activityModel.AcceptSignalAction;
import org.modelio.metamodel.uml.behavior.activityModel.AcceptTimeEventAction;
import org.modelio.metamodel.uml.behavior.activityModel.ActivityFinalNode;
import org.modelio.metamodel.uml.behavior.activityModel.ActivityParameterNode;
import org.modelio.metamodel.uml.behavior.activityModel.CallBehaviorAction;
import org.modelio.metamodel.uml.behavior.activityModel.CallOperationAction;
import org.modelio.metamodel.uml.behavior.activityModel.CentralBufferNode;
import org.modelio.metamodel.uml.behavior.activityModel.ConditionalNode;
import org.modelio.metamodel.uml.behavior.activityModel.ControlFlow;
import org.modelio.metamodel.uml.behavior.activityModel.DataStoreNode;
import org.modelio.metamodel.uml.behavior.activityModel.DecisionMergeNode;
import org.modelio.metamodel.uml.behavior.activityModel.ExceptionHandler;
import org.modelio.metamodel.uml.behavior.activityModel.ExpansionNode;
import org.modelio.metamodel.uml.behavior.activityModel.ExpansionRegion;
import org.modelio.metamodel.uml.behavior.activityModel.FlowFinalNode;
import org.modelio.metamodel.uml.behavior.activityModel.ForkJoinNode;
import org.modelio.metamodel.uml.behavior.activityModel.InitialNode;
import org.modelio.metamodel.uml.behavior.activityModel.InputPin;
import org.modelio.metamodel.uml.behavior.activityModel.InstanceNode;
import org.modelio.metamodel.uml.behavior.activityModel.LoopNode;
import org.modelio.metamodel.uml.behavior.activityModel.ObjectFlow;
import org.modelio.metamodel.uml.behavior.activityModel.ObjectNode;
import org.modelio.metamodel.uml.behavior.activityModel.OpaqueAction;
import org.modelio.metamodel.uml.behavior.activityModel.OutputPin;
import org.modelio.metamodel.uml.behavior.activityModel.SendSignalAction;
import org.modelio.metamodel.uml.behavior.activityModel.StructuredActivityNode;
import org.modelio.metamodel.uml.behavior.activityModel.ValuePin;
import org.modelio.metamodel.uml.behavior.commonBehaviors.Signal;
import org.modelio.metamodel.uml.behavior.communicationModel.CommunicationChannel;
import org.modelio.metamodel.uml.behavior.communicationModel.CommunicationNode;
import org.modelio.metamodel.uml.behavior.interactionModel.ExecutionOccurenceSpecification;
import org.modelio.metamodel.uml.behavior.interactionModel.ExecutionSpecification;
import org.modelio.metamodel.uml.behavior.interactionModel.Gate;
import org.modelio.metamodel.uml.behavior.interactionModel.Interaction;
import org.modelio.metamodel.uml.behavior.interactionModel.InteractionUse;
import org.modelio.metamodel.uml.behavior.interactionModel.Lifeline;
import org.modelio.metamodel.uml.behavior.interactionModel.Message;
import org.modelio.metamodel.uml.behavior.interactionModel.PartDecomposition;
import org.modelio.metamodel.uml.behavior.stateMachineModel.ChoicePseudoState;
import org.modelio.metamodel.uml.behavior.stateMachineModel.ConnectionPointReference;
import org.modelio.metamodel.uml.behavior.stateMachineModel.DeepHistoryPseudoState;
import org.modelio.metamodel.uml.behavior.stateMachineModel.EntryPointPseudoState;
import org.modelio.metamodel.uml.behavior.stateMachineModel.ExitPointPseudoState;
import org.modelio.metamodel.uml.behavior.stateMachineModel.FinalState;
import org.modelio.metamodel.uml.behavior.stateMachineModel.ForkPseudoState;
import org.modelio.metamodel.uml.behavior.stateMachineModel.InitialPseudoState;
import org.modelio.metamodel.uml.behavior.stateMachineModel.JoinPseudoState;
import org.modelio.metamodel.uml.behavior.stateMachineModel.JunctionPseudoState;
import org.modelio.metamodel.uml.behavior.stateMachineModel.ShallowHistoryPseudoState;
import org.modelio.metamodel.uml.behavior.stateMachineModel.State;
import org.modelio.metamodel.uml.behavior.stateMachineModel.TerminatePseudoState;
import org.modelio.metamodel.uml.behavior.stateMachineModel.Transition;
import org.modelio.metamodel.uml.behavior.usecaseModel.Actor;
import org.modelio.metamodel.uml.behavior.usecaseModel.UseCase;
import org.modelio.metamodel.uml.behavior.usecaseModel.UseCaseDependency;
import org.modelio.metamodel.uml.informationFlow.DataFlow;
import org.modelio.metamodel.uml.informationFlow.InformationFlow;
import org.modelio.metamodel.uml.infrastructure.Abstraction;
import org.modelio.metamodel.uml.infrastructure.Substitution;
import org.modelio.metamodel.uml.infrastructure.UmlModelElement;
import org.modelio.metamodel.uml.infrastructure.Usage;
import org.modelio.metamodel.uml.statik.Artifact;
import org.modelio.metamodel.uml.statik.Association;
import org.modelio.metamodel.uml.statik.AssociationEnd;
import org.modelio.metamodel.uml.statik.Attribute;
import org.modelio.metamodel.uml.statik.BindableInstance;
import org.modelio.metamodel.uml.statik.Binding;
import org.modelio.metamodel.uml.statik.Class;
import org.modelio.metamodel.uml.statik.ClassAssociation;
import org.modelio.metamodel.uml.statik.Classifier;
import org.modelio.metamodel.uml.statik.Collaboration;
import org.modelio.metamodel.uml.statik.CollaborationUse;
import org.modelio.metamodel.uml.statik.Component;
import org.modelio.metamodel.uml.statik.ComponentRealization;
import org.modelio.metamodel.uml.statik.Connector;
import org.modelio.metamodel.uml.statik.ConnectorEnd;
import org.modelio.metamodel.uml.statik.DataType;
import org.modelio.metamodel.uml.statik.ElementImport;
import org.modelio.metamodel.uml.statik.ElementRealization;
import org.modelio.metamodel.uml.statik.Enumeration;
import org.modelio.metamodel.uml.statik.Generalization;
import org.modelio.metamodel.uml.statik.Instance;
import org.modelio.metamodel.uml.statik.Interface;
import org.modelio.metamodel.uml.statik.InterfaceRealization;
import org.modelio.metamodel.uml.statik.Link;
import org.modelio.metamodel.uml.statik.LinkEnd;
import org.modelio.metamodel.uml.statik.Manifestation;
import org.modelio.metamodel.uml.statik.NaryAssociation;
import org.modelio.metamodel.uml.statik.Node;
import org.modelio.metamodel.uml.statik.Operation;
import org.modelio.metamodel.uml.statik.Package;
import org.modelio.metamodel.uml.statik.PackageImport;
import org.modelio.metamodel.uml.statik.PackageMerge;
import org.modelio.metamodel.uml.statik.Parameter;
import org.modelio.metamodel.uml.statik.Port;
import org.modelio.metamodel.uml.statik.ProvidedInterface;
import org.modelio.metamodel.uml.statik.RaisedException;
import org.modelio.metamodel.uml.statik.RequiredInterface;
import org.modelio.metamodel.uml.statik.TemplateBinding;
import org.modelio.vcore.smkernel.mapi.MClass;
import org.modelio.vcore.smkernel.mapi.MMetamodel;
import org.modelio.vcore.smkernel.mapi.MObject;

/**
 * Default creation expert that uses the {@link MetamodelRules} to answer.
 */
@objid ("6094c532-1f4d-11e2-8009-002564c97630")
public class DefaultLinkExpert implements ILinkExpert {
    @objid ("0050a578-d281-1098-bcec-001ec947cd2a")
    private final MetamodelRules RULES;

    @objid ("6094c53b-1f4d-11e2-8009-002564c97630")
    @Override
    public boolean canLink(MClass linkMetaclass, MObject from, MObject to) {
        return this.RULES.canLink(linkMetaclass, from.getMClass(), to.getMClass());
    }

    @objid ("6094c546-1f4d-11e2-8009-002564c97630")
    @Override
    public boolean canLink(MClass linkMetaclass, MClass from, MClass to) {
        return this.RULES.canLink(linkMetaclass, from, to);
    }

    @objid ("6094c54f-1f4d-11e2-8009-002564c97630")
    @Override
    public boolean canSource(MObject linkElement, MObject from) {
        return this.RULES.canSource(linkElement.getMClass(), from.getMClass());
    }

    @objid ("6094c558-1f4d-11e2-8009-002564c97630")
    @Override
    public boolean canSource(MClass linkMetaclass, final MClass fromMetaclass) {
        return this.RULES.canSource(linkMetaclass, fromMetaclass);
    }

    @objid ("005629e4-d07d-1098-bcec-001ec947cd2a")
    @Override
    public boolean canTarget(MClass linkMetaclass, MClass toMetaclass) {
        return this.RULES.canTarget(linkMetaclass, toMetaclass);
    }

    @objid ("005658ce-d07d-1098-bcec-001ec947cd2a")
    @Override
    public boolean canTarget(MObject linkElement, MObject to) {
        return this.RULES.canTarget(linkElement.getMClass(), to.getMClass());
    }

    @objid ("b703336c-beb4-4120-89be-3a6eab130e7e")
    public  DefaultLinkExpert(MMetamodel mm) {
        this.RULES = new MetamodelRules(mm);
    }

    /**
     * This class contains the metamodel knowledge of the {@link DefaultCreationExpert}.
     * <p>
     * A CreationExpert tool can answer the following questions:
     * <ol>
     * <li>can I create an object X under an Y object ?</li>
     * <li>can I create a link D from an X to an Y</li>
     * <li>can I start a link D from an X</li>
     * </ol>
     * where X, Y and D are metaclass names.
     * </p>
     * <p>
     * Example:<br/>
     * <tt>CreationExpert.canLink(IAssociation.class, IClass.class, IClass.class)</tt> => returns true
     * </p>
     */
    @objid ("65067e81-1f4f-11e2-8009-002564c97630")
    private static class MetamodelRules {
        @objid ("656353f8-1f4f-11e2-8009-002564c97630")
        private final Set<String> directRules = new HashSet<>();

        @objid ("00419998-e013-1098-bcec-001ec947cd2a")
        private final Set<String> reversedRules = new HashSet<>();

        @objid ("9903340a-257b-46a0-b56e-bc6d24dce857")
        private static final String ANY = "any";

        @objid ("b05326c5-c128-4dee-8749-f53c7e0617c4")
        private final MMetamodel mm;

        /**
         * Tells whether a link of the given metaclass can have another metaclass as source.
         * @param linkMetaclass The link metaclass
         * @param fromMetaclass The source metaclass
         * @return true if the creation is possible, false otherwise.
         */
        @objid ("65067e8f-1f4f-11e2-8009-002564c97630")
        public boolean canSource(final MClass linkMetaclass, MClass fromMetaclass) {
            final String linkMetaclassName = linkMetaclass.getQualifiedName();
            if (linkMetaclassName.equals(InformationFlow.MQNAME)) {
                // InformationFlow can link ANY UmlModelElement, but we do not want to add thousands of rules for it...
                return UmlModelElement.class.isAssignableFrom(fromMetaclass.getJavaInterface());
            }
            
            final String fromMetaclassName = fromMetaclass.getQualifiedName();
            return this.directRules.contains(linkMetaclassName + fromMetaclassName)
                                            || this.directRules.contains(linkMetaclassName + MetamodelRules.ANY);
        }

        /**
         * Tells whether a link of the given metaclass can be created between the 2 other metaclasses.
         * @param linkMetaclass The link metaclass
         * @param fromMetaclass The Source metaclass
         * @param toMetaclass The destination metaclass
         * @return true if the creation is possible, false otherwise.
         */
        @objid ("65067e97-1f4f-11e2-8009-002564c97630")
        public boolean canLink(final MClass linkMetaclass, MClass fromMetaclass, MClass toMetaclass) {
            final String linkMetaclassName = linkMetaclass.getQualifiedName();
            if (linkMetaclassName.equals(InformationFlow.MQNAME)) {
                // InformationFlow can link ANY UmlModelElement, but we do not want to add thousands of rules for it...
                return UmlModelElement.class.isAssignableFrom(fromMetaclass.getJavaInterface())
                        && UmlModelElement.class.isAssignableFrom(toMetaclass.getJavaInterface());
            }
            
            final String fromMetaclassName = fromMetaclass.getQualifiedName();
            final String toMetaclassName = toMetaclass.getQualifiedName();
            return this.directRules.contains(linkMetaclassName + fromMetaclassName + toMetaclassName)
                                            || this.directRules.contains(linkMetaclassName + fromMetaclassName + MetamodelRules.ANY)
                                            || this.directRules.contains(linkMetaclassName + MetamodelRules.ANY + MetamodelRules.ANY);
        }

        @objid ("65067ea0-1f4f-11e2-8009-002564c97630")
        public  MetamodelRules(MMetamodel mm) {
            this.mm = mm;
            
            // Use several methods to avoid the java length limit
            registerUmlLinks1();
            registerUmlLinks2();
            registerUmlLinks3();
            
            registerBpmnLinks1();
            registerBpmnLinks2();
            
        }

        /**
         * LINK CREATION RULES link", source.MQNAME, "target
         */
        @objid ("65067ea5-1f4f-11e2-8009-002564c97630")
        private void registerUmlLinks1() {
            // Abstraction (same as dependency)
            addRule(Abstraction.MQNAME, MetamodelRules.ANY, MetamodelRules.ANY);
            
            // Association
            addRule(AssociationEnd.MQNAME, Actor.MQNAME, Actor.MQNAME);
            addRule(AssociationEnd.MQNAME, Actor.MQNAME, Class.MQNAME);
            addRule(AssociationEnd.MQNAME, Actor.MQNAME, Component.MQNAME);
            addRule(AssociationEnd.MQNAME, Actor.MQNAME, Interface.MQNAME);
            addRule(AssociationEnd.MQNAME, Actor.MQNAME, UseCase.MQNAME);
            addRule(AssociationEnd.MQNAME, Artifact.MQNAME, Artifact.MQNAME);
            addRule(AssociationEnd.MQNAME, Artifact.MQNAME, Class.MQNAME);
            addRule(AssociationEnd.MQNAME, Artifact.MQNAME, DataType.MQNAME);
            addRule(AssociationEnd.MQNAME, Artifact.MQNAME, Interface.MQNAME);
            addRule(AssociationEnd.MQNAME, Artifact.MQNAME, Signal.MQNAME);
            addRule(AssociationEnd.MQNAME, Class.MQNAME, Class.MQNAME);
            addRule(AssociationEnd.MQNAME, Class.MQNAME, DataType.MQNAME);
            addRule(AssociationEnd.MQNAME, Class.MQNAME, Enumeration.MQNAME);
            addRule(AssociationEnd.MQNAME, Class.MQNAME, Interface.MQNAME);
            addRule(AssociationEnd.MQNAME, Class.MQNAME, Signal.MQNAME);
            addRule(AssociationEnd.MQNAME, Component.MQNAME, Class.MQNAME);
            addRule(AssociationEnd.MQNAME, Component.MQNAME, Component.MQNAME);
            addRule(AssociationEnd.MQNAME, Component.MQNAME, DataType.MQNAME);
            addRule(AssociationEnd.MQNAME, Component.MQNAME, Interface.MQNAME);
            addRule(AssociationEnd.MQNAME, Component.MQNAME, Signal.MQNAME);
            addRule(AssociationEnd.MQNAME, DataType.MQNAME, Class.MQNAME);
            addRule(AssociationEnd.MQNAME, DataType.MQNAME, DataType.MQNAME);
            addRule(AssociationEnd.MQNAME, DataType.MQNAME, Interface.MQNAME);
            addRule(AssociationEnd.MQNAME, DataType.MQNAME, Node.MQNAME);
            addRule(AssociationEnd.MQNAME, DataType.MQNAME, Signal.MQNAME);
            addRule(AssociationEnd.MQNAME, Enumeration.MQNAME, Class.MQNAME);
            addRule(AssociationEnd.MQNAME, Enumeration.MQNAME, DataType.MQNAME);
            addRule(AssociationEnd.MQNAME, Enumeration.MQNAME, Interface.MQNAME);
            addRule(AssociationEnd.MQNAME, Enumeration.MQNAME, Signal.MQNAME);
            addRule(AssociationEnd.MQNAME, Interface.MQNAME, Class.MQNAME);
            addRule(AssociationEnd.MQNAME, Interface.MQNAME, DataType.MQNAME);
            addRule(AssociationEnd.MQNAME, Interface.MQNAME, Enumeration.MQNAME);
            addRule(AssociationEnd.MQNAME, Interface.MQNAME, Interface.MQNAME);
            addRule(AssociationEnd.MQNAME, Node.MQNAME, Node.MQNAME);
            addRule(AssociationEnd.MQNAME, Signal.MQNAME, Class.MQNAME);
            addRule(AssociationEnd.MQNAME, Signal.MQNAME, DataType.MQNAME);
            addRule(AssociationEnd.MQNAME, Signal.MQNAME, Interface.MQNAME);
            addRule(AssociationEnd.MQNAME, Signal.MQNAME, Signal.MQNAME);
            addRule(AssociationEnd.MQNAME, UseCase.MQNAME, Actor.MQNAME);
            addRule(AssociationEnd.MQNAME, UseCase.MQNAME, Class.MQNAME);
            addRule(AssociationEnd.MQNAME, UseCase.MQNAME, UseCase.MQNAME);
            
            addRule(Association.MQNAME, Actor.MQNAME, Actor.MQNAME);
            addRule(Association.MQNAME, Actor.MQNAME, Class.MQNAME);
            addRule(Association.MQNAME, Actor.MQNAME, Component.MQNAME);
            addRule(Association.MQNAME, Actor.MQNAME, Interface.MQNAME);
            addRule(Association.MQNAME, Actor.MQNAME, UseCase.MQNAME);
            addRule(Association.MQNAME, Artifact.MQNAME, Artifact.MQNAME);
            addRule(Association.MQNAME, Artifact.MQNAME, Class.MQNAME);
            addRule(Association.MQNAME, Artifact.MQNAME, DataType.MQNAME);
            addRule(Association.MQNAME, Artifact.MQNAME, Interface.MQNAME);
            addRule(Association.MQNAME, Artifact.MQNAME, Signal.MQNAME);
            addRule(Association.MQNAME, Class.MQNAME, Class.MQNAME);
            addRule(Association.MQNAME, Class.MQNAME, DataType.MQNAME);
            addRule(Association.MQNAME, Class.MQNAME, Enumeration.MQNAME);
            addRule(Association.MQNAME, Class.MQNAME, Interface.MQNAME);
            addRule(Association.MQNAME, Class.MQNAME, Signal.MQNAME);
            addRule(Association.MQNAME, Component.MQNAME, Class.MQNAME);
            addRule(Association.MQNAME, Component.MQNAME, Component.MQNAME);
            addRule(Association.MQNAME, Component.MQNAME, DataType.MQNAME);
            addRule(Association.MQNAME, Component.MQNAME, Interface.MQNAME);
            addRule(Association.MQNAME, Component.MQNAME, Signal.MQNAME);
            addRule(Association.MQNAME, DataType.MQNAME, Class.MQNAME);
            addRule(Association.MQNAME, DataType.MQNAME, DataType.MQNAME);
            addRule(Association.MQNAME, DataType.MQNAME, Interface.MQNAME);
            addRule(Association.MQNAME, DataType.MQNAME, Node.MQNAME);
            addRule(Association.MQNAME, DataType.MQNAME, Signal.MQNAME);
            addRule(Association.MQNAME, Enumeration.MQNAME, Class.MQNAME);
            addRule(Association.MQNAME, Enumeration.MQNAME, DataType.MQNAME);
            addRule(Association.MQNAME, Enumeration.MQNAME, Interface.MQNAME);
            addRule(Association.MQNAME, Enumeration.MQNAME, Signal.MQNAME);
            addRule(Association.MQNAME, Interface.MQNAME, Class.MQNAME);
            addRule(Association.MQNAME, Interface.MQNAME, DataType.MQNAME);
            addRule(Association.MQNAME, Interface.MQNAME, Enumeration.MQNAME);
            addRule(Association.MQNAME, Interface.MQNAME, Interface.MQNAME);
            addRule(Association.MQNAME, Node.MQNAME, Node.MQNAME);
            addRule(Association.MQNAME, Signal.MQNAME, Class.MQNAME);
            addRule(Association.MQNAME, Signal.MQNAME, DataType.MQNAME);
            addRule(Association.MQNAME, Signal.MQNAME, Interface.MQNAME);
            addRule(Association.MQNAME, Signal.MQNAME, Signal.MQNAME);
            addRule(Association.MQNAME, UseCase.MQNAME, Actor.MQNAME);
            addRule(Association.MQNAME, UseCase.MQNAME, Class.MQNAME);
            addRule(Association.MQNAME, UseCase.MQNAME, UseCase.MQNAME);
            
            // Binding
            addRule(Binding.MQNAME, CollaborationUse.MQNAME, AssociationEnd.MQNAME);
            addRule(Binding.MQNAME, CollaborationUse.MQNAME, Attribute.MQNAME);
            addRule(Binding.MQNAME, CollaborationUse.MQNAME, BindableInstance.MQNAME);
            addRule(Binding.MQNAME, CollaborationUse.MQNAME, ConnectorEnd.MQNAME);
            addRule(Binding.MQNAME, CollaborationUse.MQNAME, Parameter.MQNAME);
            addRule(Binding.MQNAME, AssociationEnd.MQNAME, BindableInstance.MQNAME);
            addRule(Binding.MQNAME, AssociationEnd.MQNAME, ConnectorEnd.MQNAME);
            addRule(Binding.MQNAME, Attribute.MQNAME, BindableInstance.MQNAME);
            addRule(Binding.MQNAME, Attribute.MQNAME, ConnectorEnd.MQNAME);
            addRule(Binding.MQNAME, BindableInstance.MQNAME, BindableInstance.MQNAME);
            addRule(Binding.MQNAME, BindableInstance.MQNAME, ConnectorEnd.MQNAME);
            addRule(Binding.MQNAME, ConnectorEnd.MQNAME, BindableInstance.MQNAME);
            addRule(Binding.MQNAME, ConnectorEnd.MQNAME, ConnectorEnd.MQNAME);
            addRule(Binding.MQNAME, Parameter.MQNAME, BindableInstance.MQNAME);
            addRule(Binding.MQNAME, Parameter.MQNAME, ConnectorEnd.MQNAME);
            addRule(ClassAssociation.MQNAME, AssociationEnd.MQNAME, Class.MQNAME);
            addRule(ClassAssociation.MQNAME, NaryAssociation.MQNAME, Class.MQNAME);
            
            // CollaborationUse in link mode
            addRule(CollaborationUse.MQNAME, Actor.MQNAME, Collaboration.MQNAME);
            addRule(CollaborationUse.MQNAME, Class.MQNAME, Collaboration.MQNAME);
            addRule(CollaborationUse.MQNAME, Collaboration.MQNAME, Collaboration.MQNAME);
            addRule(CollaborationUse.MQNAME, Component.MQNAME, Collaboration.MQNAME);
            addRule(CollaborationUse.MQNAME, Node.MQNAME, Collaboration.MQNAME);
            addRule(CollaborationUse.MQNAME, Operation.MQNAME, Collaboration.MQNAME);
            addRule(CollaborationUse.MQNAME, Package.MQNAME, Collaboration.MQNAME);
            addRule(CollaborationUse.MQNAME, UseCase.MQNAME, Collaboration.MQNAME);
            
            // CommunicationChannel
            addRule(CommunicationChannel.MQNAME, CommunicationNode.MQNAME, CommunicationNode.MQNAME);
            
            // ComponentRealization
            addRule(ComponentRealization.MQNAME, Classifier.MQNAME, true, Component.MQNAME, true);
            
            // ConnectorEnd
            addRule(ConnectorEnd.MQNAME, BindableInstance.MQNAME, BindableInstance.MQNAME);
            addRule(ConnectorEnd.MQNAME, BindableInstance.MQNAME, Port.MQNAME);
            addRule(ConnectorEnd.MQNAME, Port.MQNAME, BindableInstance.MQNAME);
            addRule(ConnectorEnd.MQNAME, Port.MQNAME, Port.MQNAME);
            
            addRule(Connector.MQNAME, BindableInstance.MQNAME, BindableInstance.MQNAME);
            addRule(Connector.MQNAME, BindableInstance.MQNAME, Port.MQNAME);
            addRule(Connector.MQNAME, Port.MQNAME, BindableInstance.MQNAME);
            addRule(Connector.MQNAME, Port.MQNAME, Port.MQNAME);
            
            // ControlFlow
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptCallEventAction.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptChangeEventAction.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptSignalAction.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, AcceptTimeEventAction.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, ActivityParameterNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallBehaviorAction.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, CallOperationAction.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, CentralBufferNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, ConditionalNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, DataStoreNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, DecisionMergeNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, ForkJoinNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, InitialNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, InstanceNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, LoopNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, OpaqueAction.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, OutputPin.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, SendSignalAction.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, InputPin.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, InstanceNode.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, LoopNode.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, OutputPin.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ControlFlow.MQNAME, StructuredActivityNode.MQNAME, StructuredActivityNode.MQNAME);
            
            // DataFlow
            addRule(DataFlow.MQNAME, Actor.MQNAME, Actor.MQNAME);
            addRule(DataFlow.MQNAME, Actor.MQNAME, Artifact.MQNAME);
            addRule(DataFlow.MQNAME, Actor.MQNAME, Class.MQNAME);
            addRule(DataFlow.MQNAME, Actor.MQNAME, Component.MQNAME);
            addRule(DataFlow.MQNAME, Actor.MQNAME, Interface.MQNAME);
            addRule(DataFlow.MQNAME, Actor.MQNAME, Node.MQNAME);
            addRule(DataFlow.MQNAME, Actor.MQNAME, Package.MQNAME);
            addRule(DataFlow.MQNAME, Actor.MQNAME, UseCase.MQNAME);
            addRule(DataFlow.MQNAME, Artifact.MQNAME, Actor.MQNAME);
            addRule(DataFlow.MQNAME, Artifact.MQNAME, Artifact.MQNAME);
            addRule(DataFlow.MQNAME, Artifact.MQNAME, Class.MQNAME);
            addRule(DataFlow.MQNAME, Artifact.MQNAME, Component.MQNAME);
            addRule(DataFlow.MQNAME, Artifact.MQNAME, Interface.MQNAME);
            addRule(DataFlow.MQNAME, Artifact.MQNAME, Node.MQNAME);
            addRule(DataFlow.MQNAME, Artifact.MQNAME, Package.MQNAME);
            addRule(DataFlow.MQNAME, Artifact.MQNAME, UseCase.MQNAME);
            addRule(DataFlow.MQNAME, Class.MQNAME, Actor.MQNAME);
            addRule(DataFlow.MQNAME, Class.MQNAME, Artifact.MQNAME);
            addRule(DataFlow.MQNAME, Class.MQNAME, Class.MQNAME);
            addRule(DataFlow.MQNAME, Class.MQNAME, Component.MQNAME);
            addRule(DataFlow.MQNAME, Class.MQNAME, Interface.MQNAME);
            addRule(DataFlow.MQNAME, Class.MQNAME, Node.MQNAME);
            addRule(DataFlow.MQNAME, Class.MQNAME, Package.MQNAME);
            addRule(DataFlow.MQNAME, Class.MQNAME, UseCase.MQNAME);
            addRule(DataFlow.MQNAME, Component.MQNAME, Actor.MQNAME);
            addRule(DataFlow.MQNAME, Component.MQNAME, Artifact.MQNAME);
            addRule(DataFlow.MQNAME, Component.MQNAME, Class.MQNAME);
            addRule(DataFlow.MQNAME, Component.MQNAME, Component.MQNAME);
            addRule(DataFlow.MQNAME, Component.MQNAME, Interface.MQNAME);
            addRule(DataFlow.MQNAME, Component.MQNAME, Node.MQNAME);
            addRule(DataFlow.MQNAME, Component.MQNAME, Package.MQNAME);
            addRule(DataFlow.MQNAME, Component.MQNAME, UseCase.MQNAME);
            addRule(DataFlow.MQNAME, Interface.MQNAME, Actor.MQNAME);
            addRule(DataFlow.MQNAME, Interface.MQNAME, Artifact.MQNAME);
            addRule(DataFlow.MQNAME, Interface.MQNAME, Class.MQNAME);
            addRule(DataFlow.MQNAME, Interface.MQNAME, Component.MQNAME);
            addRule(DataFlow.MQNAME, Interface.MQNAME, Interface.MQNAME);
            addRule(DataFlow.MQNAME, Interface.MQNAME, Node.MQNAME);
            addRule(DataFlow.MQNAME, Interface.MQNAME, Package.MQNAME);
            addRule(DataFlow.MQNAME, Interface.MQNAME, UseCase.MQNAME);
            addRule(DataFlow.MQNAME, Node.MQNAME, Actor.MQNAME);
            addRule(DataFlow.MQNAME, Node.MQNAME, Artifact.MQNAME);
            addRule(DataFlow.MQNAME, Node.MQNAME, Class.MQNAME);
            addRule(DataFlow.MQNAME, Node.MQNAME, Component.MQNAME);
            addRule(DataFlow.MQNAME, Node.MQNAME, Interface.MQNAME);
            addRule(DataFlow.MQNAME, Node.MQNAME, Node.MQNAME);
            addRule(DataFlow.MQNAME, Node.MQNAME, Package.MQNAME);
            addRule(DataFlow.MQNAME, Node.MQNAME, UseCase.MQNAME);
            addRule(DataFlow.MQNAME, Package.MQNAME, Actor.MQNAME);
            addRule(DataFlow.MQNAME, Package.MQNAME, Artifact.MQNAME);
            addRule(DataFlow.MQNAME, Package.MQNAME, Class.MQNAME);
            addRule(DataFlow.MQNAME, Package.MQNAME, Component.MQNAME);
            addRule(DataFlow.MQNAME, Package.MQNAME, Interface.MQNAME);
            addRule(DataFlow.MQNAME, Package.MQNAME, Node.MQNAME);
            addRule(DataFlow.MQNAME, Package.MQNAME, Package.MQNAME);
            addRule(DataFlow.MQNAME, Package.MQNAME, UseCase.MQNAME);
            addRule(DataFlow.MQNAME, UseCase.MQNAME, Actor.MQNAME);
            addRule(DataFlow.MQNAME, UseCase.MQNAME, Artifact.MQNAME);
            addRule(DataFlow.MQNAME, UseCase.MQNAME, Class.MQNAME);
            addRule(DataFlow.MQNAME, UseCase.MQNAME, Component.MQNAME);
            addRule(DataFlow.MQNAME, UseCase.MQNAME, Interface.MQNAME);
            addRule(DataFlow.MQNAME, UseCase.MQNAME, Node.MQNAME);
            addRule(DataFlow.MQNAME, UseCase.MQNAME, Package.MQNAME);
            addRule(DataFlow.MQNAME, UseCase.MQNAME, UseCase.MQNAME);
            
            // ExceptionHandler
            addRule(ExceptionHandler.MQNAME, AcceptCallEventAction.MQNAME, InputPin.MQNAME);
            addRule(ExceptionHandler.MQNAME, AcceptChangeEventAction.MQNAME, InputPin.MQNAME);
            addRule(ExceptionHandler.MQNAME, AcceptSignalAction.MQNAME, InputPin.MQNAME);
            addRule(ExceptionHandler.MQNAME, AcceptTimeEventAction.MQNAME, InputPin.MQNAME);
            addRule(ExceptionHandler.MQNAME, CallBehaviorAction.MQNAME, InputPin.MQNAME);
            addRule(ExceptionHandler.MQNAME, CallOperationAction.MQNAME, InputPin.MQNAME);
            addRule(ExceptionHandler.MQNAME, ConditionalNode.MQNAME, InputPin.MQNAME);
            addRule(ExceptionHandler.MQNAME, ExpansionRegion.MQNAME, InputPin.MQNAME);
            addRule(ExceptionHandler.MQNAME, LoopNode.MQNAME, InputPin.MQNAME);
            addRule(ExceptionHandler.MQNAME, OpaqueAction.MQNAME, InputPin.MQNAME);
            addRule(ExceptionHandler.MQNAME, SendSignalAction.MQNAME, InputPin.MQNAME);
            addRule(ExceptionHandler.MQNAME, StructuredActivityNode.MQNAME, InputPin.MQNAME);
            
            // ElementImport
            addRule(ElementImport.MQNAME, Actor.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, Actor.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, Artifact.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, Class.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, Collaboration.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, Component.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, DataType.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, Enumeration.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, Interface.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, ModuleComponent.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, Node.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, Operation.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, Package.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, Signal.MQNAME, UseCase.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, Actor.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, Artifact.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, Class.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, Collaboration.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, Component.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, DataType.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, Enumeration.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, Interface.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, ModuleComponent.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, Node.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, Package.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, Signal.MQNAME);
            addRule(ElementImport.MQNAME, UseCase.MQNAME, UseCase.MQNAME);
            
            // ElementRealization
            addRule(ElementRealization.MQNAME, MetamodelRules.ANY, MetamodelRules.ANY);
            
            // Generalization
            addRule(Generalization.MQNAME, Actor.MQNAME, Actor.MQNAME);
            addRule(Generalization.MQNAME, Artifact.MQNAME, Artifact.MQNAME);
            addRule(Generalization.MQNAME, Class.MQNAME, Class.MQNAME);
            addRule(Generalization.MQNAME, Collaboration.MQNAME, Collaboration.MQNAME);
            addRule(Generalization.MQNAME, Component.MQNAME, Component.MQNAME);
            addRule(Generalization.MQNAME, DataType.MQNAME, DataType.MQNAME);
            addRule(Generalization.MQNAME, Interface.MQNAME, Interface.MQNAME);
            addRule(Generalization.MQNAME, Node.MQNAME, Node.MQNAME);
            addRule(Generalization.MQNAME, Signal.MQNAME, Class.MQNAME);
            addRule(Generalization.MQNAME, Signal.MQNAME, Signal.MQNAME);
            addRule(Generalization.MQNAME, UseCase.MQNAME, UseCase.MQNAME);
            
        }

        @objid ("65067ea8-1f4f-11e2-8009-002564c97630")
        private void registerUmlLinks2() {
            // InformationFlow
            addRule(InformationFlow.MQNAME, UmlModelElement.MQNAME, UmlModelElement.MQNAME);
            
            // InterfaceRealization
            addRule(InterfaceRealization.MQNAME, Class.MQNAME, Interface.MQNAME);
            addRule(InterfaceRealization.MQNAME, Collaboration.MQNAME, Interface.MQNAME);
            addRule(InterfaceRealization.MQNAME, Component.MQNAME, Interface.MQNAME);
            addRule(InterfaceRealization.MQNAME, Enumeration.MQNAME, Interface.MQNAME);
            
            // LinkEnd
            addRule(LinkEnd.MQNAME, Instance.MQNAME, Instance.MQNAME);
            addRule(LinkEnd.MQNAME, Instance.MQNAME, BindableInstance.MQNAME);
            addRule(LinkEnd.MQNAME, BindableInstance.MQNAME, Instance.MQNAME);
            addRule(LinkEnd.MQNAME, BindableInstance.MQNAME, BindableInstance.MQNAME);
            
            addRule(Link.MQNAME, Instance.MQNAME, Instance.MQNAME);
            addRule(Link.MQNAME, Instance.MQNAME, BindableInstance.MQNAME);
            addRule(Link.MQNAME, BindableInstance.MQNAME, Instance.MQNAME);
            addRule(Link.MQNAME, BindableInstance.MQNAME, BindableInstance.MQNAME);
            
            // Manifestation
            addRule(Manifestation.MQNAME, Artifact.MQNAME, Actor.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, Artifact.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, Class.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, Collaboration.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, Component.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, DataType.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, Enumeration.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, Instance.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, Interface.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, Node.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, Package.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, Signal.MQNAME);
            addRule(Manifestation.MQNAME, Artifact.MQNAME, UseCase.MQNAME);
            
            // Message
            addRule(Message.MQNAME, ExecutionOccurenceSpecification.MQNAME, ExecutionOccurenceSpecification.MQNAME);
            addRule(Message.MQNAME, ExecutionOccurenceSpecification.MQNAME, ExecutionSpecification.MQNAME);
            addRule(Message.MQNAME, ExecutionOccurenceSpecification.MQNAME, Gate.MQNAME);
            addRule(Message.MQNAME, ExecutionOccurenceSpecification.MQNAME, Interaction.MQNAME);
            addRule(Message.MQNAME, ExecutionOccurenceSpecification.MQNAME, InteractionUse.MQNAME);
            addRule(Message.MQNAME, ExecutionOccurenceSpecification.MQNAME, Lifeline.MQNAME);
            addRule(Message.MQNAME, ExecutionOccurenceSpecification.MQNAME, PartDecomposition.MQNAME);
            addRule(Message.MQNAME, ExecutionSpecification.MQNAME, ExecutionOccurenceSpecification.MQNAME);
            addRule(Message.MQNAME, ExecutionSpecification.MQNAME, ExecutionSpecification.MQNAME);
            addRule(Message.MQNAME, ExecutionSpecification.MQNAME, Gate.MQNAME);
            addRule(Message.MQNAME, ExecutionSpecification.MQNAME, Interaction.MQNAME);
            addRule(Message.MQNAME, ExecutionSpecification.MQNAME, InteractionUse.MQNAME);
            addRule(Message.MQNAME, ExecutionSpecification.MQNAME, Lifeline.MQNAME);
            addRule(Message.MQNAME, ExecutionSpecification.MQNAME, PartDecomposition.MQNAME);
            addRule(Message.MQNAME, Gate.MQNAME, ExecutionOccurenceSpecification.MQNAME);
            addRule(Message.MQNAME, Gate.MQNAME, ExecutionSpecification.MQNAME);
            addRule(Message.MQNAME, Gate.MQNAME, Gate.MQNAME);
            addRule(Message.MQNAME, Gate.MQNAME, Interaction.MQNAME);
            addRule(Message.MQNAME, Gate.MQNAME, InteractionUse.MQNAME);
            addRule(Message.MQNAME, Gate.MQNAME, Lifeline.MQNAME);
            addRule(Message.MQNAME, Gate.MQNAME, PartDecomposition.MQNAME);
            addRule(Message.MQNAME, Interaction.MQNAME, ExecutionOccurenceSpecification.MQNAME);
            addRule(Message.MQNAME, Interaction.MQNAME, ExecutionSpecification.MQNAME);
            addRule(Message.MQNAME, Interaction.MQNAME, Gate.MQNAME);
            addRule(Message.MQNAME, Interaction.MQNAME, InteractionUse.MQNAME);
            addRule(Message.MQNAME, Interaction.MQNAME, Lifeline.MQNAME);
            addRule(Message.MQNAME, Interaction.MQNAME, PartDecomposition.MQNAME);
            addRule(Message.MQNAME, InteractionUse.MQNAME, ExecutionOccurenceSpecification.MQNAME);
            addRule(Message.MQNAME, InteractionUse.MQNAME, ExecutionSpecification.MQNAME);
            addRule(Message.MQNAME, InteractionUse.MQNAME, Gate.MQNAME);
            addRule(Message.MQNAME, InteractionUse.MQNAME, Interaction.MQNAME);
            addRule(Message.MQNAME, InteractionUse.MQNAME, InteractionUse.MQNAME);
            addRule(Message.MQNAME, InteractionUse.MQNAME, Lifeline.MQNAME);
            addRule(Message.MQNAME, InteractionUse.MQNAME, PartDecomposition.MQNAME);
            addRule(Message.MQNAME, Lifeline.MQNAME, ExecutionOccurenceSpecification.MQNAME);
            addRule(Message.MQNAME, Lifeline.MQNAME, ExecutionSpecification.MQNAME);
            addRule(Message.MQNAME, Lifeline.MQNAME, Gate.MQNAME);
            addRule(Message.MQNAME, Lifeline.MQNAME, Interaction.MQNAME);
            addRule(Message.MQNAME, Lifeline.MQNAME, InteractionUse.MQNAME);
            addRule(Message.MQNAME, Lifeline.MQNAME, Lifeline.MQNAME);
            addRule(Message.MQNAME, Lifeline.MQNAME, PartDecomposition.MQNAME);
            addRule(Message.MQNAME, PartDecomposition.MQNAME, ExecutionOccurenceSpecification.MQNAME);
            addRule(Message.MQNAME, PartDecomposition.MQNAME, ExecutionSpecification.MQNAME);
            addRule(Message.MQNAME, PartDecomposition.MQNAME, Gate.MQNAME);
            addRule(Message.MQNAME, PartDecomposition.MQNAME, Interaction.MQNAME);
            addRule(Message.MQNAME, PartDecomposition.MQNAME, InteractionUse.MQNAME);
            addRule(Message.MQNAME, PartDecomposition.MQNAME, Lifeline.MQNAME);
            addRule(Message.MQNAME, PartDecomposition.MQNAME, PartDecomposition.MQNAME);
            
            // ObjectFlow
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptCallEventAction.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptChangeEventAction.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptSignalAction.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, AcceptTimeEventAction.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ActivityParameterNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, CallBehaviorAction.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, CallOperationAction.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, CentralBufferNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ConditionalNode.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DataStoreNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, DecisionMergeNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ExpansionNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ForkJoinNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InitialNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InputPin.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, InstanceNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, LoopNode.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ObjectNode.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, OpaqueAction.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, OutputPin.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, AcceptCallEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, AcceptChangeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, AcceptSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, AcceptTimeEventAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, CallBehaviorAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, CallOperationAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, ConditionalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, LoopNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, OpaqueAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, SendSignalAction.MQNAME);
            addRule(ObjectFlow.MQNAME, ValuePin.MQNAME, StructuredActivityNode.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, SendSignalAction.MQNAME, ValuePin.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, ActivityFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, ActivityParameterNode.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, CentralBufferNode.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, DataStoreNode.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, DecisionMergeNode.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, FlowFinalNode.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, ForkJoinNode.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, InputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, ExpansionNode.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, InstanceNode.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, ObjectNode.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, OutputPin.MQNAME);
            addRule(ObjectFlow.MQNAME, StructuredActivityNode.MQNAME, ValuePin.MQNAME);
            
        }

        @objid ("65067eaa-1f4f-11e2-8009-002564c97630")
        private void registerUmlLinks3() {
            // PackageImport
            addRule(PackageImport.MQNAME, Actor.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, Artifact.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, Class.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, Collaboration.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, Component.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, DataType.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, Enumeration.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, Interface.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, Node.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, Operation.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, Package.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, Signal.MQNAME, Package.MQNAME);
            addRule(PackageImport.MQNAME, UseCase.MQNAME, Package.MQNAME);
            
            // PackageMerge
            addRule(PackageMerge.MQNAME, Package.MQNAME, Package.MQNAME);
            
            // ProvidedInterface
            addRule(ProvidedInterface.MQNAME, Port.MQNAME, ProvidedInterface.MQNAME);
            addRule(ProvidedInterface.MQNAME, Port.MQNAME, RequiredInterface.MQNAME);
            
            // RaisedException
            addRule(RaisedException.MQNAME, Operation.MQNAME, Class.MQNAME);
            addRule(RaisedException.MQNAME, Operation.MQNAME, DataType.MQNAME);
            addRule(RaisedException.MQNAME, Operation.MQNAME, Enumeration.MQNAME);
            addRule(RaisedException.MQNAME, Operation.MQNAME, Interface.MQNAME);
            
            // RequiredInterface
            addRule(RequiredInterface.MQNAME, Port.MQNAME, ProvidedInterface.MQNAME);
            addRule(RequiredInterface.MQNAME, Port.MQNAME, RequiredInterface.MQNAME);
            
            // Substitution
            addRule(Substitution.MQNAME, Classifier.MQNAME, true, Classifier.MQNAME, true);
            
            // TemplateBinding
            addRule(TemplateBinding.MQNAME, Artifact.MQNAME, Artifact.MQNAME);
            addRule(TemplateBinding.MQNAME, Class.MQNAME, Class.MQNAME);
            addRule(TemplateBinding.MQNAME, Class.MQNAME, DataType.MQNAME);
            addRule(TemplateBinding.MQNAME, Collaboration.MQNAME, Collaboration.MQNAME);
            addRule(TemplateBinding.MQNAME, Component.MQNAME, Component.MQNAME);
            addRule(TemplateBinding.MQNAME, DataType.MQNAME, Class.MQNAME);
            addRule(TemplateBinding.MQNAME, DataType.MQNAME, DataType.MQNAME);
            addRule(TemplateBinding.MQNAME, Enumeration.MQNAME, Enumeration.MQNAME);
            addRule(TemplateBinding.MQNAME, Interface.MQNAME, Interface.MQNAME);
            addRule(TemplateBinding.MQNAME, Node.MQNAME, Node.MQNAME);
            addRule(TemplateBinding.MQNAME, Operation.MQNAME, Operation.MQNAME);
            addRule(TemplateBinding.MQNAME, Package.MQNAME, Package.MQNAME);
            addRule(TemplateBinding.MQNAME, Signal.MQNAME, Signal.MQNAME);
            addRule(TemplateBinding.MQNAME, UseCase.MQNAME, UseCase.MQNAME);
            
            // Transition
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, ConnectionPointReference.MQNAME);
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, ChoicePseudoState.MQNAME, TerminatePseudoState.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, ConnectionPointReference.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, ConnectionPointReference.MQNAME, TerminatePseudoState.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, ConnectionPointReference.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, DeepHistoryPseudoState.MQNAME, TerminatePseudoState.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, ConnectionPointReference.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, EntryPointPseudoState.MQNAME, TerminatePseudoState.MQNAME);
            addRule(Transition.MQNAME, ExitPointPseudoState.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, ExitPointPseudoState.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, ExitPointPseudoState.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, ExitPointPseudoState.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, ExitPointPseudoState.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, ExitPointPseudoState.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, ExitPointPseudoState.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, ExitPointPseudoState.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, ExitPointPseudoState.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, ExitPointPseudoState.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, ExitPointPseudoState.MQNAME, TerminatePseudoState.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, ConnectionPointReference.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, ForkPseudoState.MQNAME, TerminatePseudoState.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, ConnectionPointReference.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, InitialPseudoState.MQNAME, TerminatePseudoState.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, ConnectionPointReference.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, JoinPseudoState.MQNAME, TerminatePseudoState.MQNAME);
            addRule(Transition.MQNAME, JunctionPseudoState.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, JunctionPseudoState.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, JunctionPseudoState.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, JunctionPseudoState.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, JunctionPseudoState.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, JunctionPseudoState.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, JunctionPseudoState.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, JunctionPseudoState.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, JunctionPseudoState.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, JunctionPseudoState.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, JunctionPseudoState.MQNAME, TerminatePseudoState.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, ConnectionPointReference.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, ShallowHistoryPseudoState.MQNAME, TerminatePseudoState.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, ConnectionPointReference.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, State.MQNAME, TerminatePseudoState.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, ChoicePseudoState.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, ConnectionPointReference.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, DeepHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, EntryPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, ExitPointPseudoState.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, FinalState.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, ForkPseudoState.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, JoinPseudoState.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, JunctionPseudoState.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, ShallowHistoryPseudoState.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, State.MQNAME);
            addRule(Transition.MQNAME, TerminatePseudoState.MQNAME, TerminatePseudoState.MQNAME);
            
            // Usage (same as dependency)
            addRule(Usage.MQNAME, MetamodelRules.ANY, MetamodelRules.ANY);
            
            // UseCaseDependency
            addRule(UseCaseDependency.MQNAME, UseCase.MQNAME, UseCase.MQNAME);
            
        }

        @objid ("65067eae-1f4f-11e2-8009-002564c97630")
        private void registerBpmnLinks1() {
            // BpmnMessageFlow
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTransaction.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnTask.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnManualTask.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnSendTask.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnUserTask.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnParticipant.MQNAME);
            // An End Event MAY be the source for Message Flow; it can have 0 (zero) or more outgoing Message Flow.
            // An End Event MUST NOT be the target for Message Flow; it can have no incoming Message Flow.
            // A Start Event MUST NOT be a source for Message Flow; it MUST NOT have outgoing Message Flow.
            // A Start Event MAY be the target for Message Flow; it can have 0 (zero) or more incoming Message Flow.
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnEndEvent.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnParticipant.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnStartEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnMessageFlow.MQNAME, BpmnParticipant.MQNAME, BpmnUserTask.MQNAME);
            
        }

        @objid ("65067eb2-1f4f-11e2-8009-002564c97630")
        private void registerBpmnLinks2() {
            // BpmnSequenceFlow
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnActivity.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBoundaryEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnBusinessRuleTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCallActivity.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnCatchEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnComplexGateway.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnEventBasedGateway.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnExclusiveGateway.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnGateway.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnImplicitThrowEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnInclusiveGateway.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateCatchEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnIntermediateThrowEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnManualTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnParallelGateway.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnReceiveTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnScriptTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSendTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnServiceTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnStartEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnSubProcess.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTask.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnThrowEvent.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnTransaction.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnBoundaryEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnComplexGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnEndEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnEventBasedGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnExclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnImplicitThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnInclusiveGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnIntermediateCatchEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnIntermediateThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnParallelGateway.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnReceiveTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnThrowEvent.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnSequenceFlow.MQNAME, BpmnUserTask.MQNAME, BpmnUserTask.MQNAME);
            
            // BpmnDataAssociation
            addRule(BpmnDataAssociation.MQNAME, BpmnActivity.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnActivity.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnActivity.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnActivity.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnAdHocSubProcess.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnCallActivity.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnCallActivity.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnCallActivity.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnCallActivity.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataInput.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataObject.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataOutput.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnActivity.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnAdHocSubProcess.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnBusinessRuleTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnCallActivity.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnCatchEvent.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnManualTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnScriptTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnSendTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnServiceTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnSubProcess.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnTransaction.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnDataStore.MQNAME, BpmnUserTask.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnManualTask.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnManualTask.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnManualTask.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnManualTask.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnReceiveTask.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnReceiveTask.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnReceiveTask.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnReceiveTask.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnSendTask.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnSendTask.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnSendTask.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnSendTask.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnSendTask.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnSendTask.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnSendTask.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnServiceTask.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnServiceTask.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnServiceTask.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnServiceTask.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnSubProcess.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnSubProcess.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnSubProcess.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnSubProcess.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnTask.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnTask.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnTask.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnTask.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnThrowEvent.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnThrowEvent.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnThrowEvent.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnThrowEvent.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnTransaction.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnTransaction.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnTransaction.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnTransaction.MQNAME, BpmnDataStore.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnUserTask.MQNAME, BpmnDataInput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnUserTask.MQNAME, BpmnDataObject.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnUserTask.MQNAME, BpmnDataOutput.MQNAME);
            addRule(BpmnDataAssociation.MQNAME, BpmnUserTask.MQNAME, BpmnDataStore.MQNAME);
            
        }

        @objid ("65067eb8-1f4f-11e2-8009-002564c97630")
        private void addRule(String mcD, String mcX, String mcY) {
            // Add 'canSource' and 'canLink' rules
            this.directRules.add(mcD + mcX);
            this.directRules.add(mcD + mcX + mcY);
            
            // Add 'canTarget' rules in a different set to avoid collisions
            this.reversedRules.add(mcD + mcY);
            
        }

        /**
         * Returns whether this metaclass is known or not.
         * @param metaclass
         * the sought metaclass.
         * @param linkMetaclass The link metaclass
         * @param toMetaclass The target metaclass
         * @return true if the creation is possible, false otherwise.
         */
        @objid ("003d421c-e013-1098-bcec-001ec947cd2a")
        public boolean canTarget(final MClass linkMetaclass, MClass toMetaclass) {
            final String linkMetaclassName = linkMetaclass.getQualifiedName();
            if (linkMetaclassName.equals(InformationFlow.MQNAME)) {
                // InformationFlow can link ANY UmlModelElement, but we do not want to add thousands of rules for it...
                return UmlModelElement.class.isAssignableFrom(toMetaclass.getJavaInterface());
            }
            
            final String toMetaclassName = toMetaclass.getQualifiedName();
            return this.reversedRules.contains(linkMetaclassName + toMetaclassName)
                                            || this.reversedRules.contains(linkMetaclassName + MetamodelRules.ANY);
        }

        @objid ("68f433b4-cbbd-48b0-849d-d17623c39633")
        private void addRule(String mcD, String mcX, boolean xRec, String mcY, boolean yRec) {
            // Add 'canSource' and 'canLink' rules
            this.directRules.add(mcD + mcX);
            this.directRules.add(mcD + mcX + mcY);
            
            // Add 'canTarget' rules in a different set to avoid collisions
            this.reversedRules.add(mcD + mcY);
            
            if (xRec) {
                MClass mx = this.mm.getMClass(mcX);
                for (MClass xsub : mx.getSub(false)) {
                    addRule(mcD, xsub.getQualifiedName(), true, mcY, yRec);
                }
            }
            
            if (yRec) {
                MClass my = this.mm.getMClass(mcY);
                for (MClass ysub : my.getSub(false)) {
                    addRule(mcD, mcX, xRec, ysub.getQualifiedName(), true);
                }
            }
            
        }

    }

}
